/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package chess.trainer;
import java.util.ArrayList;
    

/**
 *
 * @author Garcia Cadavid
 */
public class Nodo {
    String estado[][];
    String operacionAplicada[];
    /*Operacion aplicada contiene la ficha movida,la direccion del movimiento y el numero de casillas*/
    Nodo padre;
    int altura;
    String tipo;
    int posiciones[][]=new int[16][2];
    int color;
    String[]fichas={"p","P","p","P","p","P","p","P","b","B","h","H","q","Q","k","K"};
    String direcciones[]={"N","NE","E","SE","S","SO","O","NO"};

    public Nodo(int posiciones[][], String[] operacionAplicada, Nodo padre,int color) {       
        this.posiciones=posiciones;
        this.operacionAplicada = operacionAplicada;
        this.padre = padre;
        this.color=color;
        GenerarEstado();
      
    }
    
   public void GenerarEstado()
   {
       int posicion[]=new int[2];
       for (int i = 0; i < 6; i++) {
           for (int j = 0; j < 6; j++) {
               estado[i][j]="0";               
           }           
       }
       for (int i = 0; i < 16; i++) {
           posicion=posiciones[i];
           estado[posicion[0]][posicion[1]]=fichas[i];
       }
   }
    
   
    
    public ArrayList<Nodo> DeterminarPosiblesJugadas()
    {
        ArrayList<Nodo> jugadas=new ArrayList<Nodo>();
        int inicio=color;
        for (int i = inicio; i < 16; i=i+2) {
            if(posiciones[i][0]!=-1)jugadas.addAll(Mover(posiciones[i],i));            
        }
        
        return jugadas;
    }
    
    boolean CasillaBlanca(int posicion[])
    {
        boolean valido=true;
        int x=posicion[0],y=posicion[1];
        if((x<6)&&(x>=0)&&(x<6)&&(x>=0))
        {
            if(!estado[posicion[0]][posicion[1]].equals("0"))valido=false;
            
        }else valido=false;
        
        return valido;        
    }
    
    int IndiceFicha(int posicion[])
    {
        int pos=-1,i=0;
        while(i<16)
        {
            if(posiciones[i]==posicion){
                pos=i;
                break;
            }else i++;
        }
        return pos;        
    }
    
    boolean FichaContraria(int posicion[])
    {
      boolean contraria=false;
      int index=IndiceFicha(posicion);
      if(index>0)
      {
          if((index%2)==(color+1)%2)contraria=true;
      }
      return contraria;
    }
    
    public ArrayList<Nodo> Mover(int posicion[],int indiceFicha)
    {
        int cambioPosiciones[][]=posiciones;
        int x=posicion[0],y=posicion[1];
        int dir,index,cont;
        String ficha=fichas[indiceFicha];
        int incrementos[][]=new int[8][2];
        ArrayList<Nodo> jugadas=new ArrayList<Nodo>();
        if(ficha.equals("p"))
        {
           if(x<5)
           {
               if(CasillaBlanca(new int[]{x+1,y}))
               {
                   cambioPosiciones[indiceFicha]=new int[]{x+1,y};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"S","1"},this,(this.color+1)%2));
                   cambioPosiciones=posiciones;
               }
               dir=5;
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x+1,i}))
                   {
                       cambioPosiciones[indiceFicha]=new int[]{x+1,i};
                       index=IndiceFicha(new int[]{x+1,i});
                       cambioPosiciones[index]=new int[]{-1,-1};
                       jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[dir],"1"},this,(this.color+1)%2));
                       cambioPosiciones=posiciones; 
                   }
                   dir-=2;
               }
           }
        }
        else if(ficha.equals("P"))
        {
            if(x>0)
           {
               if(CasillaBlanca(new int[]{x-1,y}))
               {
                   cambioPosiciones[indiceFicha]=new int[]{x-1,y};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"N","1"},this,(this.color+1)%2));
                   cambioPosiciones=posiciones;
               }
               dir=7;
               for(int i=y-1;i<=y+1;i=i+2)
               {
                   if(FichaContraria(new int[]{x-1,i}))
                   {
                       cambioPosiciones[indiceFicha]=new int[]{x-1,i};
                       index=IndiceFicha(new int[]{x-1,i});
                       cambioPosiciones[index]=new int[]{-1,-1};
                       jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[dir],"1"},this,(this.color+1)%2));
                       cambioPosiciones=posiciones; 
                   }
                   dir-=6;
               }
           }
        }
        else if(ficha.equals("b")||ficha.equals("B"))
        {
            cont=1;
            
            for(int i=x-1;i>=0;i--)
            {
                if(CasillaBlanca(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
            cont=1;
            for(int i=x+1;i<6;i++)
            {
                if(CasillaBlanca(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
        }
        else if(ficha.equals("h")||ficha.equals("H"))
        {           
           incrementos[0][0]=incrementos[1][0]=incrementos[7][1]=incrementos[6][1]=-2;
           incrementos[7][0]=incrementos[2][0]=incrementos[0][1]=incrementos[5][1]=-1;
           incrementos[6][0]=incrementos[3][0]=incrementos[1][1]=incrementos[4][1]=1;
           incrementos[5][0]=incrementos[4][0]=incrementos[2][1]=incrementos[3][1]=2;
            int incremento[];
           for (int i = 0; i < 8; i++) {
               incremento=incrementos[i];
                if(CasillaBlanca(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[i],"3"},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   index=IndiceFicha(new int[]{x+incremento[0],y+incremento[1]});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[i],"3"},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
            }
           
        }
        else if(ficha.equals("q")||ficha.equals("Q"))
        {
            cont=1;
            for(int i=x-1;i>=0;i--)
            {
                if(CasillaBlanca(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"NE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"N",String.valueOf(x-i)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   index=IndiceFicha(new int[]{i,y});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"N",String.valueOf(x-i)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
            cont=1;
            for(int i=x+1;i<6;i++)
            {
                if(CasillaBlanca(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y-cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y-cont}; 
                   index=IndiceFicha(new int[]{i,y-cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SO",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y+cont}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y+cont}; 
                   index=IndiceFicha(new int[]{i,y+cont});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"SE",String.valueOf(cont)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                
                if(CasillaBlanca(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"S",String.valueOf(i-x)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{i,y}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{i,y}; 
                   index=IndiceFicha(new int[]{i,y});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"S",String.valueOf(i-x)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
                cont++;
            }
            for(int i=y-1;i>=0;i--)
            {
             if(CasillaBlanca(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"O",String.valueOf(y-i)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   index=IndiceFicha(new int[]{x,i});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"O",String.valueOf(y-i)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }   
            }
            
            for(int i=y+1;i<6;i++)
            {
             if(CasillaBlanca(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"E",String.valueOf(i-y)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x,i}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x,i}; 
                   index=IndiceFicha(new int[]{x,i});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],"E",String.valueOf(i-y)},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }   
            }
        }else if(ficha.equals("k")||ficha.equals("K"))
        {
            incrementos[0][0]=incrementos[1][0]=incrementos[7][0]=incrementos[1][1]=incrementos[2][1]=incrementos[3][1]=1;
            incrementos[2][0]=incrementos[6][0]=incrementos[0][1]=incrementos[4][1]=0;
            incrementos[3][0]=incrementos[4][0]=incrementos[5][0]=incrementos[5][1]=incrementos[6][1]=incrementos[7][1]=-1;
            int incremento[];
           for (int i = 0; i < 8; i++) {
               incremento=incrementos[i];
                if(CasillaBlanca(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[i],"1"},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }else if(FichaContraria(new int[]{x+incremento[0],y+incremento[1]}))
                {
                   cambioPosiciones[indiceFicha]=new int[]{x+incremento[0],y+incremento[1]}; 
                   index=IndiceFicha(new int[]{x+incremento[0],y+incremento[1]});
                   cambioPosiciones[index]=new int[]{-1,-1};
                   jugadas.add(new Nodo(cambioPosiciones,new String[]{fichas[indiceFicha],direcciones[i],"1"},this,(color+1)%2));
                   cambioPosiciones=posiciones;
                }
            }
        }
        return jugadas;
    }
    
    public void AlgoritmoMinimax(int profundidad)
    {
        
    }
    
    
}
